//---------------------------------------------------------------------------

#include <vcl.h>
#pragma hdrstop

#include "Circulo.h"


//--------------------------------------------------------------------------
Circulo::Circulo(PV2D* centro, double radio){
        _centro=centro;
        _radio=radio;
        _relleno=Pelota::dibujaCirculo(_centro,radio);
        _normal=NULL;
}

Circulo::~Circulo(){

        delete _centro;
        list<PV2D*>::iterator it;
        PV2D* node;
        for (it = _relleno->begin(); it != _relleno->end(); it++) {
                node = *it;
                delete node;
        }
        delete _relleno;

        if(_normal!=NULL){
                delete _normal;
        }
}

void Circulo::pintaObstaculo(bool depurando){
        list<PV2D*>::iterator it;
        PV2D* node;
        glBegin(GL_LINE_LOOP);//glBegin(GL_POLYGON);
        glColor3f(1,1,1);
        for (it = _relleno->begin(); it != _relleno->end(); it++) {
                node = *it;
                glVertex2d(node->getX(),node->getY());
        }
        glEnd();
}

void Circulo::intersecar(bool& exito,double& tHit,PV2D*& leNormal,
        Pelota* lePelota){
        /*
        double tin=0;
        double tout=1;

        double x=_centro->getX()-lePelota->getCentro()->getX();
        double y=_centro->getY()-lePelota->getCentro()->getY();
        double modulo= sqrt((x*x)+(y*y));

        if(modulo>_radio+radio_pelota+1){
                exito=false;
        }else{
                exito=true;
                tHit=modulo-(_radio+radio_pelota);
                if(_normal!=NULL){
                        delete _normal;
                }
                _normal=new PV2D(x/modulo, y/modulo,1);
                leNormal=_normal;
        }*/

        double t,t1,t2,A,B,C,AC,modulo,raiz;
        PV2D* v=lePelota->getSentido();
        PV2D* CA_=new PV2D(lePelota->getCentro()->getX()-_centro->getX(),
                                lePelota->getCentro()->getY()-_centro->getY(),0);

        A=lePelota->getSentido()->productoEscalar(v);
        B=(CA_->productoEscalar(v))*2.0;
        //C=(CA_->productoEscalar(CA_))-(_radio*_radio);
        C=(CA_->productoEscalar(CA_))-((_radio+radio_pelota)*(_radio+radio_pelota));
        AC=A*C;
        raiz=(B*B)-4*AC;
        if(raiz<0){
                exito=false;
                delete CA_;
        }else if(A!=0){
                raiz=sqrt(raiz);
                t1=(-B+raiz)/2*A;
                t2=(-B-raiz)/2*A;
                t=min(t1,t2);
                //t=max(t1,t2);

                //if(t>=_radio+0.001+radio_pelota){
                /*if(t1>=_radio+radio_pelota && t1<=_radio+1+radio_pelota){
                        exito=true;
                        tHit=t1-_radio-radio_pelota;
                        if(_normal!=NULL){
                                delete _normal;
                        }
                        CA_->normaliza();
                        _normal=CA_;
                        leNormal=_normal;
                /*}else if(t2>=_radio+radio_pelota && t2<=_radio+1+radio_pelota){
                        exito=true;
                        tHit=t2-_radio-radio_pelota;
                        if(_normal!=NULL){
                                delete _normal;
                        }
                        CA_->normaliza();
                        _normal=CA_;
                        leNormal=_normal; */
                if(t<tHit && t>0){
                        exito=true;
                        tHit=t;
                        if(_normal!=NULL){
                                delete _normal;
                        }
                        CA_->normaliza();
                        _normal=CA_;
                        leNormal=_normal;
                
                }else{
                        exito=false;
                        delete CA_;
                }
        }
}
//---------------------------------------------------------------------------

#pragma package(smart_init)
